import { ElMessage } from 'element-plus';
import axios from 'axios';

// 从环境变量获取API基础路径
const API_BASE_URL = import.meta.env.VITE_API_URL || 'http://localhost:8080';
const API_PREFIX = import.meta.env.VITE_BASE_URL || '/api';

// 角色管理相关接口
const ROLE_LIST_ENDPOINT = '/role/list';     // 角色列表查询接口
const ROLE_ADD_ENDPOINT = '/role/add';              // 添加角色接口
const ROLE_UPDATE_ENDPOINT = '/role/update';        // 更新角色接口
const ROLE_DELETE_ENDPOINT = '/user/del';           // 批量删除接口
const MENU_LIST_ENDPOINT = '/menu/list';            // 获取全部菜单接口
const MENU_UPDATE_ENDPOINT = '/role/upMenu'         //菜单权限修改

// 创建axios实例
const axiosInstance = axios.create({
  baseURL: API_BASE_URL,
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
});

// 设置请求拦截器，添加认证令牌
axiosInstance.interceptors.request.use(
  (config) => {
    // 从localStorage获取token并添加Bearer前缀
    const token = localStorage.getItem('token');
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`;
    }
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

// 角色管理接口
export const roleService = {
  // 获取角色列表数据，支持分页和搜索
  async getRoleList(page = 1, pageSize = 20, searchParams = {}): Promise<any> {
    try {
      // 构建查询参数
      const queryParams = new URLSearchParams({
        page: page.toString(),
        pageSize: pageSize.toString()
      });
      
      // 如果有搜索条件，添加到查询参数中
      if (Object.keys(searchParams).length > 0) {
        queryParams.append('where', JSON.stringify(searchParams));
      }
      
      const apiUrl = `${API_PREFIX}${ROLE_LIST_ENDPOINT}?${queryParams.toString()}`;
      console.log('API: 请求角色列表, URL:', apiUrl);
      
      const response = await axiosInstance.get(apiUrl);
      console.log('API: 角色列表接口原始响应:', response);
      
      // 检查响应结构
      if (response.data) {
        // 检查常见的数据格式
        // 格式1: { code: 200, data: [...] }
        if (response.data.code === 200 && Array.isArray(response.data.data)) {
          console.log('API: 获取角色列表成功, 数量:', response.data.data.length);
          return {
            list: response.data.data,
            total: response.data.total || response.data.data.length
          };
        }
        // 格式2: { code: 200, data: { rows: [...], total: n } }
        else if (response.data.code === 200 && response.data.data && Array.isArray(response.data.data.rows)) {
          console.log('API: 获取角色列表成功 (rows格式), 数量:', response.data.data.rows.length);
          // 确保rows数据中每个角色的menus字段存在
          const roleList = response.data.data.rows.map((role: any) => {
            // 如果menus字段不存在，设置为空数组
            if (!role.menus) {
              role.menus = [];
            }
            return role;
          });
          
          return {
            list: roleList,
            total: response.data.data.total || roleList.length
          };
        }
        // 格式3: { code: 200, data: { list: [...], total: n } }
        else if (response.data.code === 200 && response.data.data && Array.isArray(response.data.data.list)) {
          console.log('API: 获取角色列表成功 (list格式), 数量:', response.data.data.list.length);
          // 确保list数据中每个角色的menus字段存在
          const roleList = response.data.data.list.map((role: any) => {
            // 如果menus字段不存在，设置为空数组
            if (!role.menus) {
              role.menus = [];
            }
            return role;
          });
          
          return {
            list: roleList,
            total: response.data.data.total || roleList.length
          };
        }
        // 格式4: 直接返回数组
        else if (Array.isArray(response.data)) {
          console.log('API: 获取角色列表成功 (直接数组), 数量:', response.data.length);
          // 确保数组中每个角色的menus字段存在
          const roleList = response.data.map((role: any) => {
            // 如果menus字段不存在，设置为空数组
            if (!role.menus) {
              role.menus = [];
            }
            return role;
          });
          
          return {
            list: roleList,
            total: roleList.length
          };
        }
        // 无法处理的格式，返回空数组
        else {
          console.warn('API: 角色列表数据格式不符合预期:', response.data);
          ElMessage.warning('角色数据格式异常，请联系管理员');
          return { list: [], total: 0 };
        }
      } else {
        // 响应格式异常
        console.error('API: 角色列表接口响应格式异常:', response);
        ElMessage.error('获取角色列表失败，响应格式异常');
        return { list: [], total: 0 };
      }
    } catch (error) {
      // 网络错误或其他异常
      console.error('API: 获取角色列表请求失败:', error);
      ElMessage.error('获取角色列表失败，请检查网络连接');
      return { list: [], total: 0 };
    }
  },

  // 添加角色
  async addRole(roleData: any): Promise<any> {
    try {
      const apiUrl = `${API_PREFIX}${ROLE_ADD_ENDPOINT}`;
      console.log('添加角色，URL:', apiUrl, '参数:', roleData);
      
      const response = await axiosInstance.post(apiUrl, roleData);
      
      if (response.data && response.data.code === 200) {
        console.log('添加角色成功:', response.data);
        ElMessage.success('添加角色成功');
        return response.data.data;
      } else {
        console.error('添加角色失败:', response.data);
        ElMessage.error(response.data?.message || '添加角色失败');
        throw new Error(response.data?.message || '添加角色接口返回异常');
      }
    } catch (error: any) {
      console.error('添加角色请求失败:', error);
      ElMessage.error(error.message || '添加角色失败');
      throw error;
    }
  },

  // 更新角色
  async updateRole(roleData: any): Promise<any> {
    try {
      const apiUrl = `${API_PREFIX}${ROLE_UPDATE_ENDPOINT}`;
      console.log('更新角色，URL:', apiUrl, '参数:', roleData);
      
      const response = await axiosInstance.put(apiUrl, roleData);
      
      if (response.data && response.data.code === 200) {
        console.log('更新角色成功:', response.data);
        ElMessage.success('更新角色成功');
        return response.data.data;
      } else {
        console.error('更新角色失败:', response.data);
        ElMessage.error(response.data?.message || '更新角色失败');
        throw new Error(response.data?.message || '更新角色接口返回异常');
      }
    } catch (error: any) {
      console.error('更新角色请求失败:', error);
      ElMessage.error(error.message || '更新角色失败');
      throw error;
    }
  },

  // 删除角色
  async deleteRoles(ids: number[]): Promise<any> {
    try {
      const apiUrl = `${API_PREFIX}${ROLE_DELETE_ENDPOINT}`;
      console.log('删除角色，URL:', apiUrl, '参数:', { id: ids });
      
      const response = await axiosInstance.delete(apiUrl, {
        data: { id: ids } // 按照接口规范传递id数组
      });
      
      if (response.data && response.data.code === 200) {
        console.log('删除角色成功:', response.data);
        ElMessage.success('删除角色成功');
        return response.data.data;
      } else {
        console.error('删除角色失败:', response.data);
        ElMessage.error(response.data?.message || '删除角色失败');
        throw new Error(response.data?.message || '删除角色接口返回异常');
      }
    } catch (error: any) {
      console.error('删除角色请求失败:', error);
      ElMessage.error(error.message || '删除角色失败');
      throw error;
    }
  },

  // 获取完整的菜单列表
  async getAllMenus(): Promise<any[]> {
    try {
      const apiUrl = `${API_PREFIX}${MENU_LIST_ENDPOINT}`;
      console.log('API: 请求所有菜单, URL:', apiUrl);
      
      const response = await axiosInstance.get(apiUrl);
      
      if (response.data && response.data.code === 200 && Array.isArray(response.data.data)) {
        console.log('API: 获取所有菜单成功, 数量:', response.data.data.length);
        return response.data.data;
      } else {
        console.error('获取所有菜单失败:', response.data);
        ElMessage.error('获取菜单列表失败');
        return [];
      }
    } catch (error) {
      console.error('获取所有菜单请求失败:', error);
      ElMessage.error('获取菜单列表失败，请检查网络连接');
      return [];
    }
  },

  // 更新角色菜单权限
  async updateRoleMenuPermissions(roleId: number, menuIds: number[]): Promise<any> {
    try {
      const apiUrl = `${API_PREFIX}${MENU_UPDATE_ENDPOINT}`;
      console.log('更新角色菜单权限，URL:', apiUrl, '参数:', { id: roleId, menus: menuIds });
      
      // 按照接口要求的数据格式
      const roleData = {
        id: roleId,
        menus: menuIds
      };
      
      const response = await axiosInstance.post(apiUrl, roleData);
      
      if (response.data && response.data.code === 200) {
        console.log('更新角色菜单权限成功:', response.data);
        ElMessage.success('更新角色菜单权限成功');
        return response.data.data;
      } else {
        console.error('更新角色菜单权限失败:', response.data);
        ElMessage.error(response.data?.message || '更新角色菜单权限失败');
        throw new Error(response.data?.message || '更新角色菜单权限接口返回异常');
      }
    } catch (error: any) {
      console.error('更新角色菜单权限请求失败:', error);
      ElMessage.error(error.message || '更新角色菜单权限失败');
      throw error;
    }
  }
}; 